home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 198_01 / eval.c < prev    next >
C/C++ Source or Header  |  1990-01-21  |  27KB  |  1,083 lines
  1. /*    EVAL.C:    Expresion evaluation functions for
  2.         MicroEMACS
  3.  
  4.     written 1986 by Daniel Lawrence                */
  5.  
  6. #include    <stdio.h>
  7. #include    "estruct.h"
  8. #include    "edef.h"
  9. #include    "evar.h"
  10.  
  11. varinit()        /* initialize the user variable list */
  12.  
  13. {
  14.     register int i;
  15.  
  16.     for (i=0; i < MAXVARS; i++)
  17.         uv[i].u_name[0] = 0;
  18. }
  19.  
  20. char *gtfun(fname)    /* evaluate a function */
  21.  
  22. char *fname;        /* name of function to evaluate */
  23.  
  24. {
  25.     register int fnum;        /* index to function to eval */
  26.     register int arg;        /* value of some arguments */
  27.     char arg1[NSTRING];        /* value of first argument */
  28.     char arg2[NSTRING];        /* value of second argument */
  29.     char arg3[NSTRING];        /* value of third argument */
  30.     static char result[2 * NSTRING];    /* string result */
  31. #if    ENVFUNC
  32.     char *getenv();
  33. #endif
  34.  
  35.     /* look the function up in the function table */
  36.     fname[3] = 0;    /* only first 3 chars significant */
  37.     mklower(fname);    /* and let it be upper or lower case */
  38.     for (fnum = 0; fnum < NFUNCS; fnum++)
  39.         if (strcmp(fname, funcs[fnum].f_name) == 0)
  40.             break;
  41.  
  42.     /* return errorm on a bad reference */
  43.     if (fnum == NFUNCS)
  44.         return(errorm);
  45.  
  46.     /* if needed, retrieve the first argument */
  47.     if (funcs[fnum].f_type >= MONAMIC) {
  48.         if (macarg(arg1) != TRUE)
  49.             return(errorm);
  50.  
  51.         /* if needed, retrieve the second argument */
  52.         if (funcs[fnum].f_type >= DYNAMIC) {
  53.             if (macarg(arg2) != TRUE)
  54.                 return(errorm);
  55.     
  56.             /* if needed, retrieve the third argument */
  57.             if (funcs[fnum].f_type >= TRINAMIC)
  58.                 if (macarg(arg3) != TRUE)
  59.                     return(errorm);
  60.         }
  61.     }
  62.         
  63.  
  64.     /* and now evaluate it! */
  65.     switch (fnum) {
  66.         case UFADD:    return(itoa(atoi(arg1) + atoi(arg2)));
  67.         case UFSUB:    return(itoa(atoi(arg1) - atoi(arg2)));
  68.         case UFTIMES:    return(itoa(atoi(arg1) * atoi(arg2)));
  69.         case UFDIV:    return(itoa(atoi(arg1) / atoi(arg2)));
  70.         case UFMOD:    return(itoa(atoi(arg1) % atoi(arg2)));
  71.         case UFNEG:    return(itoa(-atoi(arg1)));
  72.         case UFCAT:    bytecopy(result, arg1, NSTRING-1);
  73.                 bytecopy(&result[strlen(result)], arg2,
  74.                     NSTRING-1-strlen(result));
  75.                 return(result);
  76.         case UFLEFT:    return(bytecopy(result, arg1, atoi(arg2)));
  77.         case UFRIGHT:    arg = atoi(arg2);
  78.                 if (arg > strlen(arg1)) arg = strlen(arg1);
  79.                 return(strcpy(result,
  80.                     &arg1[strlen(arg1)-arg]));
  81.         case UFMID:    arg = atoi(arg2);
  82.                 if (arg > strlen(arg1)) arg = strlen(arg1);
  83.                 return(bytecopy(result, &arg1[arg-1],
  84.                     atoi(arg3)));
  85.         case UFNOT:    return(ltos(stol(arg1) == FALSE));
  86.         case UFEQUAL:    return(ltos(atoi(arg1) == atoi(arg2)));
  87.         case UFLESS:    return(ltos(atoi(arg1) < atoi(arg2)));
  88.         case UFGREATER:    return(ltos(atoi(arg1) > atoi(arg2)));
  89.         case UFSEQUAL:    return(ltos(strcmp(arg1, arg2) == 0));
  90.         case UFSLESS:    return(ltos(strcmp(arg1, arg2) < 0));
  91.         case UFSGREAT:    return(ltos(strcmp(arg1, arg2) > 0));
  92.         case UFIND:    return(bytecopy(result, fixnull(getval(arg1)),
  93.                     NSTRING-1));
  94.         case UFAND:    return(ltos(stol(arg1) && stol(arg2)));
  95.         case UFOR:    return(ltos(stol(arg1) || stol(arg2)));
  96.         case UFLENGTH:    return(itoa(strlen(arg1)));
  97.         case UFUPPER:    return(mkupper(arg1));
  98.         case UFLOWER:    return(mklower(arg1));
  99.         case UFTRUTH:    return(ltos(atoi(arg1) == 42));
  100.         case UFASCII:    return(itoa((int)arg1[0]));
  101.         case UFCHR:    result[0] = atoi(arg1);
  102.                 result[1] = 0;
  103.                 return(result);
  104.         case UFGTCMD:    cmdstr(getcmd(), result);
  105.                 return(result);
  106.         case UFGTKEY:    result[0] = tgetc();
  107.                 result[1] = 0;
  108.                 return(result);
  109.         case UFRND:    return(itoa((ernd() % abs(atoi(arg1))) + 1));
  110.         case UFABS:    return(itoa(abs(atoi(arg1))));
  111.         case UFSINDEX:    return(itoa(sindex(arg1, arg2)));
  112.         case UFENV:
  113. #if    ENVFUNC
  114.                 return(fixnull(getenv(arg1)));
  115. #else
  116.                 return("");
  117. #endif
  118.         case UFBIND:    return(transbind(arg1));
  119.          case UFBAND:    return(int_asc(asc_int(arg1) & asc_int(arg2)));
  120.          case UFBOR:    return(int_asc(asc_int(arg1) | asc_int(arg2)));
  121.          case UFBXOR:    return(int_asc(asc_int(arg1) ^ asc_int(arg2)));
  122.         case UFBNOT:    return(int_asc(~asc_int(arg1)));
  123.     }
  124.  
  125.     exit(-11);    /* never should get here */
  126. }
  127.  
  128. char *gtusr(vname)    /* look up a user var's value */
  129.  
  130. char *vname;        /* name of user variable to fetch */
  131.  
  132. {
  133.  
  134.     register int vnum;    /* ordinal number of user var */
  135.  
  136.     /* scan the list looking for the user var name */
  137.     for (vnum = 0; vnum < MAXVARS; vnum++)
  138.         if (strcmp(vname, uv[vnum].u_name) == 0)
  139.             break;
  140.  
  141.     /* return errorm on a bad reference */
  142.     if (vnum == MAXVARS)
  143.         return(errorm);
  144.  
  145.     return(uv[vnum].u_value);
  146. }
  147.  
  148. #if    DECEDT
  149. extern int advset;
  150. #endif
  151.  
  152. char *gtenv(vname)
  153.  
  154. char *vname;        /* name of environment variable to retrieve */
  155.  
  156. {
  157.     register int vnum;    /* ordinal number of var refrenced */
  158.     char *getkill();
  159.  
  160.     /* scan the list, looking for the referenced name */
  161.     for (vnum = 0; vnum < NEVARS; vnum++)
  162.         if (strcmp(vname, envars[vnum]) == 0)
  163.             break;
  164.  
  165.     /* return errorm on a bad reference */
  166.     if (vnum == NEVARS)
  167.         return(errorm);
  168.  
  169.     /* otherwise, fetch the appropriate value */
  170.     switch (vnum) {
  171.         case EVFILLCOL:    return(itoa(fillcol));
  172.         case EVPAGELEN:    return(itoa(term.t_nrow + 1));
  173.         case EVCURCOL:    return(itoa(getccol(FALSE)));
  174.         case EVCURLINE: return(itoa(getcline()));
  175.         case EVRAM:    return(itoa((int)(envram / 1024l)));
  176.         case EVFLICKER:    return(ltos(flickcode));
  177.         case EVCURWIDTH:return(itoa(term.t_nrow));
  178.         case EVCBUFNAME:return(curbp->b_bname);
  179.         case EVCBFLAGS:    return(itoa(curbp->b_flag));
  180.         case EVCFNAME:    return(curbp->b_fname);
  181.         case EVSRES:    return(sres);
  182.         case EVDEBUG:    return(ltos(macbug));
  183.         case EVSTATUS:    return(ltos(cmdstatus));
  184.         case EVPALETTE:    return(palstr);
  185.         case EVASAVE:    return(itoa(gasave));
  186.         case EVACOUNT:    return(itoa(gacount));
  187.         case EVLASTKEY: return(itoa(lastkey));
  188.         case EVCURCHAR:
  189.             return(curwp->w_dotp->l_used ==
  190.                     curwp->w_doto ? itoa('\n') :
  191.                 itoa(lgetc(curwp->w_dotp, curwp->w_doto)));
  192.         case EVDISCMD:    return(ltos(discmd));
  193.         case EVVERSION:    return(VERSION);
  194.         case EVPROGNAME:return(PROGNAME);
  195.         case EVSEED:    return(itoa(seed));
  196.         case EVDISINP:    return(ltos(disinp));
  197.         case EVWLINE:    return(itoa(curwp->w_ntrows));
  198.         case EVCWLINE:    return(itoa(getwpos()));
  199.         case EVTARGET:    saveflag = lastflag;
  200.                 return(itoa(curgoal));
  201.         case EVSEARCH:    return(pat);
  202.         case EVREPLACE:    return(rpat);
  203.         case EVMATCH:    return((patmatch == NULL)? "": patmatch);
  204.         case EVKILL:    return(getkill());
  205.         case EVCMODE:    return(itoa(curbp->b_mode));
  206.         case EVGMODE:    return(itoa(gmode));
  207.         case EVTPAUSE:    return(itoa(term.t_pause));
  208.         case EVPENDING:
  209. #if    TYPEAH
  210.                 return(ltos(typahead()));
  211. #else
  212.                 return(falsem);
  213. #endif
  214.         case EVLWIDTH:    return(itoa(llength(curwp->w_dotp)));
  215.         case EVLINE:    return(getctext());
  216.         case EVHARDTAB:    return(int_asc(tabsize));
  217.         case EVSOFTTAB:    return(int_asc(stabsize));
  218.         case EVFCOL:    return(itoa(curwp->w_fcol));
  219.         case EVHSCROLL:    return(ltos(hscroll));
  220.         case EVHJUMP:    return(int_asc(hjump));
  221.         case EVADVANCE:
  222. #if    DECEDT
  223.             return(itoa(advset));
  224. #else
  225.             return(itoa(1));
  226. #endif
  227.         case EVVT100KEYS: return(itoa(vt100keys));
  228.     }
  229.     exit(-12);    /* again, we should never get here */
  230. }
  231.  
  232. char *fixnull(s)    /* Don't return NULL pointers! */
  233.  
  234. char *s;
  235.  
  236. {
  237.     if (s == NULL)
  238.         return("");
  239.     else
  240.         return(s);
  241. }
  242. char *getkill()        /* return some of the contents of the kill buffer */
  243.  
  244. {
  245.     register int size;    /* max number of chars to return */
  246.     static char value[NSTRING];    /* temp buffer for value */
  247.  
  248.     if (kbufh == NULL)
  249.         /* no kill buffer....just a null string */
  250.         value[0] = 0;
  251.     else {
  252.         /* copy in the contents... */
  253.         if (kused < NSTRING)
  254.             size = kused;
  255.         else
  256.             size = NSTRING - 1;
  257.         bytecopy(value, kbufh->d_chunk, size);
  258.     }
  259.  
  260.     /* and return the constructed value */
  261.     return(value);
  262. }
  263.  
  264. int setvar(f, n)        /* set a variable */
  265.  
  266. int f;        /* default flag */
  267. int n;        /* numeric arg (can overide prompted value) */
  268.  
  269. {
  270.     register int status;    /* status return */
  271.     VDESC vd;        /* variable num/type */
  272.     char var[NVSIZE+1];    /* name of variable to fetch */
  273.     char value[NSTRING];    /* value to set variable to */
  274.  
  275.     /* first get the variable to set.. */
  276.     if (clexec == FALSE) {
  277.         status = mlreply("Variable to set: ", &var[0], NVSIZE);
  278.         if (status != TRU